Pythoni 'email' paketi valdamine: MIME-sõnumite loomise ja usaldusväärse parsimise kunst

E-post on jätkuvalt globaalse suhtluse nurgakivi, asendamatu isiklikuks kirjavahetuseks, äritegevuseks ja automatiseeritud süsteemiteatisteks. Iga rikkaliku tekstiga e-kirja, iga manuse ja iga hoolikalt vormindatud allkirja taga peitub Multipurpose Internet Mail Extensions (MIME) keerukus. Arendajate jaoks, eriti nende jaoks, kes töötavad Pythoniga, on nende MIME-sõnumite programmeerimise teel loomise ja parsimise valdamine kriitilise tähtsusega oskus.

Pythoni sisseehitatud pakett email pakub tugeva ja põhjaliku raamistiku e-kirjade käsitlemiseks. See ei ole ainult lihtsa teksti saatmiseks; see on loodud MIME-i keeruliste detailide abstraheerimiseks, võimaldades teil luua keerulisi e-kirju ja eraldada sissetulevatest sõnumitest spetsiifilisi andmeid märkimisväärse täpsusega. See juhend viib teid süvitsi selle paketi kahe peamise tahuga: MIME-sõnumite loomine saatmiseks ja nende parsimine andmete ekstraheerimiseks, pakkudes globaalset vaatenurka parimatele tavadele.

Nii loomise kui ka parsimise mõistmine on ülioluline. Sõnumit luues määratlete sisuliselt selle struktuuri ja sisu, et teine süsteem saaks seda tõlgendada. Parsides tõlgendate teise süsteemi määratletud struktuuri ja sisu. Ühe sügav mõistmine aitab oluliselt kaasa teise valdamisele, mis viib vastupidavamate ja koostalitlusvõimelisemate e-posti rakendusteni.

MIME mõistmine: kaasaegse e-posti selgroog

Enne Pythoni spetsiifikasse süvenemist on oluline mõista, mis on MIME ja miks see nii elutähtis on. Algselt piirdusid e-kirjad lihttekstiga (7-bitised ASCII-märgid). MIME, mis võeti kasutusele 1990. aastate alguses, laiendas e-posti võimalusi toetama:

• Mitte-ASCII märgid: Võimaldades teksti keeltes nagu araabia, hiina, vene või mis tahes muus keeles, mis kasutab märke väljaspool ASCII kompletti.
• Manused: Failide (nt dokumendid, pildid, heli ja video) saatmine.
• Rikas tekstivorming: HTML-kirjad paksus kirjas, kursiivkirjas, värvide ja paigutustega.
• Mitu osa: Lihtteksti, HTML-i ja manuste kombineerimine ühes e-kirjas.

MIME saavutab selle, lisades e-kirjale spetsiifilised päised ja struktureerides selle sisu erinevateks "osadeks". Peamised MIME-päised, millega kokku puutute, hõlmavad:

• Content-Type: Määrab osa andmetüübi (nt text/plain, text/html, image/jpeg, application/pdf, multipart/alternative). See sisaldab sageli ka parameetrit charset (nt charset=utf-8).
• Content-Transfer-Encoding: Näitab, kuidas e-posti klient peaks sisu dekodeerima (nt base64 binaarandmete puhul, quoted-printable peamiselt teksti puhul koos mõnede mitte-ASCII märkidega).
• Content-Disposition: Soovitab, kuidas saaja e-posti klient peaks osa kuvama (nt inline kuvamiseks sõnumi kehas, attachment salvestatava faili jaoks).

Pythoni pakett email: süvaanalüüs

Pythoni pakett email on põhjalik teek, mis on loodud e-kirjade programmeerimise teel loomiseks, parsimiseks ja muutmiseks. See on üles ehitatud Message objektide kontseptsioonile, mis esindavad e-kirja struktuuri.

Paketi võtmemoodulid hõlmavad:

• email.message: Sisaldab põhilist klassi EmailMessage, mis on peamine liides e-kirjade loomiseks ja manipuleerimiseks. See on väga paindlik klass, mis käsitleb MIME-i detaile automaatselt.
• email.mime: Pakub pärandklasse (nagu MIMEText, MIMEMultipart), mis pakuvad MIME-struktuurile selgemat kontrolli. Kuigi EmailMessage on lihtsuse tõttu uue koodi jaoks üldiselt eelistatud, võib nende klasside mõistmine olla kasulik.
• email.parser: Pakub klasse nagu BytesParser ja Parser toore e-posti andmete (baitide või stringide) teisendamiseks EmailMessage objektideks.
• email.policy: Määrab poliitikad, mis kontrollivad e-kirjade loomise ja parsimise viisi, mõjutades päise kodeeringut, reavahetusi ja veakäsitlust.

Enamiku tänapäevaste kasutusjuhtude puhul suhtlete peamiselt klassiga email.message.EmailMessage nii loomiseks kui ka parsimise tulemusena saadud sõnumiobjekti jaoks. Selle meetodid lihtsustavad oluliselt protsessi, mis oli pärandklassidega email.mime varem palju mahukam.

MIME-sõnumi loomine: e-kirjade koostamine täpsusega

E-kirjade koostamine hõlmab erinevate komponentide (tekst, HTML, manused) kokkupanemist kehtivaks MIME-struktuuriks. Klass EmailMessage lihtsustab seda protsessi märkimisväärselt.

Põhilised tekstilised e-kirjad

Lihtsaim e-kiri on lihttekst. Saate sellise luua ja põhilised päised vaevata seadistada:

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Tervitused Pythonist'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Tere, see on lihtteksti e-kiri, mis on saadetud Pythonist.\n\nParimate soovidega,\nTeie Pythoni Skript')

print(msg.as_string())

Selgitus:

• EmailMessage() loob tühja sõnumiobjekti.
• Sõnastiku-laadne ligipääs (msg['Subject'] = ...) seab tavalised päised.
• set_content() lisab e-kirja põhilise sisu. Vaikimisi järeldab see Content-Type: text/plain; charset="utf-8".
• as_string() serialiseerib sõnumi stringvormingusse, mis sobib saatmiseks SMTP kaudu või salvestamiseks faili.

HTML-sisu lisamine

HTML-e-kirja saatmiseks määrate lihtsalt sisutüübi, kui kutsute välja set_content(). Hea tava on pakkuda lihtteksti alternatiivi vastuvõtjatele, kelle e-posti kliendid HTML-i ei renderda, või ligipääsetavuse põhjustel.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Teie HTML-uudiskiri'
msg['From'] = 'newsletter@example.com'
msg['To'] = 'subscriber@example.com'

html_content = """
<html>
    <head></head>
    <body>
        <h1>Tere tulemast meie globaalsesse uuendusse!</h1>
        <p>Hea tellija,</p>
        <p>See on teie <strong>viimane uuendus</strong> kogu maailmast.</p>
        <p>Lisateabe saamiseks külastage meie <a href="http://www.example.com">veebisaiti</a>.</p>
        <p>Parimate soovidega,<br>Meeskond</p>
    </body>
</html>
"""

# Add the HTML version
msg.add_alternative(html_content, subtype='html')

# Add a plain text fallback
plain_text_content = (
    "Tere tulemast meie globaalsesse uuendusse!\n\n"
    "Hea tellija,\n\n"
    "See on teie viimane uuendus kogu maailmast.\n"
    "Külastage meie veebisaiti lisateabe saamiseks: http://www.example.com\n\n"
    "Parimate soovidega,\nThe Team"
)
msg.add_alternative(plain_text_content, subtype='plain')

print(msg.as_string())

Selgitus:

• add_alternative() kasutatakse *sama* sisu erinevate esituste lisamiseks. E-posti klient kuvab "parima", mida see suudab käsitleda (tavaliselt HTML).
• See loob automaatselt multipart/alternative MIME-struktuuri.

Manuste käsitlemine

Failide lisamine on lihtne, kasutades add_attachment(). Saate lisada mis tahes tüüpi faile ja pakett käsitleb sobivaid MIME-tüüpe ja kodeeringuid (tavaliselt base64).

from email.message import EmailMessage
from pathlib import Path

# Create dummy files for demonstration
Path('report.pdf').write_bytes(b'%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Count 0>>endobj\nxref\n0 3\n0000000000 65535 f\n0000000009 00000 n\n0000000052 00000 n\ntrailer<</Size 3/Root 1 0 R>>startxref\n104\n%%EOF') # Väga lihtne, kehtetu PDF-kohatäide
Path('logo.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82') # 1x1 läbipaistev PNG-kohatäide

msg = EmailMessage()
msg['Subject'] = 'Oluline dokument ja pilt'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Palun leiate lisatud aruande ja ettevõtte logo.')

# Attach a PDF file
with open('report.pdf', 'rb') as f:
    file_data = f.read()
    msg.add_attachment(
        file_data,
        maintype='application',
        subtype='pdf',
        filename='Aastaaruanne_2024.pdf'
    )

# Attach an image file
with open('logo.png', 'rb') as f:
    image_data = f.read()
    msg.add_attachment(
        image_data,
        maintype='image',
        subtype='png',
        filename='EttevõtteLogo.png'
    )

print(msg.as_string())

# Clean up dummy files
Path('report.pdf').unlink()
Path('logo.png').unlink()

Selgitus:

• add_attachment() võtab vastu faili sisu toorbaidid.
• maintype ja subtype määravad MIME-tüübi (nt application/pdf, image/png). Need on vastuvõtja e-posti kliendi jaoks üliolulised manuse õigeks tuvastamiseks ja käsitlemiseks.
• filename annab nime, mille all vastuvõtja manuse salvestab.
• See seadistab automaatselt multipart/mixed struktuuri.

Mitmeosaliste sõnumite loomine

Kui teil on sõnum, mis sisaldab nii HTML-keha, lihtteksti varuvarianti kui ka sisemisi pilte või seotud faile, vajate keerukamat mitmeosaline struktuuri. Klass EmailMessage käsitleb seda arukalt meetoditega add_related() ja add_alternative().

Levinud stsenaarium on HTML-e-kiri koos otse HTML-i sisse manustatud pildiga (nn "inline" pilt). See kasutab multipart/related.

from email.message import EmailMessage
from pathlib import Path

# Create a dummy image file for demonstration (a 1x1 transparent PNG)
Path('banner.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82')

msg = EmailMessage()
msg['Subject'] = 'Sisepildi näide'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'

# Plain text version (fallback)
plain_text = 'Vaadake meie suurepärast bannerit!\n\n[Pilt: Banner.png]\n\nKülastage meie saiti.'
msg.set_content(plain_text, subtype='plain') # Seadistage esialgne lihtteksti sisu

# HTML version (with CID for inline image)
html_content = """
<html>
    <head></head>
    <body>
        <h1>Meie uusim pakkumine!</h1>
        <p>Hea klient,</p>
        <p>Ärge jätke kasutamata meie erilist globaalset pakkumist:</p>
        <img src="cid:my-banner-image" alt="Kampaania banner">
        <p>Lisateabe saamiseks klõpsake <a href="http://www.example.com">siin</a>.</p>
    </body>
</html>
"""

msg.add_alternative(html_content, subtype='html') # Lisage HTML-alternatiiv

# Add the inline image (related content)
with open('banner.png', 'rb') as img_file:
    image_data = img_file.read()
    msg.add_related(
        image_data,
        maintype='image',
        subtype='png',
        cid='my-banner-image' # See CID vastab HTML-i 'src' atribuudile
    )

print(msg.as_string())

# Clean up dummy file
Path('banner.png').unlink()

Selgitus:

• set_content() loob algse sisu (siin lihttekst).
• add_alternative() lisab HTML-versiooni, luues multipart/alternative struktuuri, mis sisaldab lihtteksti ja HTML-i osi.
• add_related() kasutatakse sisu jaoks, mis on "seotud" ühe sõnumi osaga, tavaliselt sisemiste piltidega HTML-is. See võtab vastu cid (Content-ID) parameetri, millele seejärel viidatakse HTML-i <img src="cid:my-banner-image"> sildis.
• Lõplik struktuur on multipart/mixed (kui oli väliseid manuseid), mis sisaldab multipart/alternative osa, mis omakorda sisaldab multipart/related osa. multipart/related osa sisaldab HTML-i ja sisemist pilti. Klass EmailMessage käsitleb seda pesastamise keerukust teie eest.

Kodeering ja märgistikud globaalseks haardeks

Rahvusvahelise suhtluse jaoks on õige märgifkodeering ülitähtis. Pakett email eelistab vaikimisi tugevalt UTF-8 kasutamist, mis on universaalne standard erinevate märgifkodeeringute käsitlemiseks kogu maailmast.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Globaalsed märgid: こんにちは, Привет, नमस्ते'
msg['From'] = 'global_sender@example.com'
msg['To'] = 'global_recipient@example.com'

# Japanese, Russian, and Hindi characters
content = "See sõnum sisaldab erinevaid globaalseid märke:\n"
content += "こんにちは (jaapani)\n"
content += "Привет (vene)\n"
content += "नमस्ते (hindi)\n\n"
content += "Pakett 'email' käsitleb UTF-8 graatsiliselt."

msg.set_content(content)

print(msg.as_string())

Selgitus:

• Kui set_content() saab Pythoni stringi, kodeerib see selle automaatselt UTF-8-ks ja seab päise Content-Type: text/plain; charset="utf-8".
• Kui sisu seda nõuab (nt sisaldab palju mitte-ASCII märke), võib see rakendada ka Content-Transfer-Encoding: quoted-printable või base64, et tagada turvaline edastus vanemate e-posti süsteemide kaudu. Pakett käsitleb seda automaatselt vastavalt valitud poliitikale.

Kohandatud päised ja poliitikad

Saate e-kirjale lisada mis tahes kohandatud päise. Poliitikad (moodulist email.policy) määravad, kuidas sõnumeid käsitletakse, mõjutades selliseid aspekte nagu päise kodeering, reavahetused ja veakäsitlus. Vaikekäitumine on üldiselt hea, kuid saate valida `SMTP` rangeks SMTP vastavuseks või määratleda kohandatud poliitikad.

from email.message import EmailMessage
from email import policy

msg = EmailMessage(policy=policy.SMTP)
msg['Subject'] = 'E-kiri kohandatud päisega'
msg['From'] = 'info@example.org'
msg['To'] = 'user@example.org'
msg['X-Custom-Header'] = 'See on kohandatud väärtus jälgimiseks'
msg['Reply-To'] = 'support@example.org'
msg.set_content('See e-kiri demonstreerib kohandatud päiseid ja poliitikaid.')

print(msg.as_string())

Selgitus:

• Kasutades policy=policy.SMTP tagatakse range vastavus SMTP standarditele, mis võib olla kohaletoimetatavuse seisukohalt kriitiline.
• Kohandatud päised lisatakse samamoodi nagu standardsed. Need algavad sageli X--ga, et tähistada mittestandardseid päiseid.

MIME-sõnumite parsimine: teabe ekstraheerimine sissetulevatest e-kirjadest

Parsimine hõlmab toore e-posti andmete (tavaliselt saadud IMAP-i kaudu või failist) võtmist ja nende teisendamist `EmailMessage` objektiks, mida saate seejärel hõlpsasti uurida ja manipuleerida.

Laadimine ja esialgne parsimine

Tavaliselt saate e-kirju toorbaididena. Selleks kasutatakse email.parser.BytesParser (või abifunktsioone email.message_from_bytes()).

from email.parser import BytesParser
from email.policy import default

raw_email_bytes = b"""
From: sender@example.com
To: recipient@example.com
Subject: Test Email with Basic Headers
Date: Mon, 1 Jan 2024 10:00:00 +0000
Content-Type: text/plain; charset="utf-8"

See on e-kirja sisu.
See on lihtne test.
"""

# Using BytesParser
parser = BytesParser(policy=default)
msg = parser.parsebytes(raw_email_bytes)

# Or using the convenience function
# from email import message_from_bytes
# msg = message_from_bytes(raw_email_bytes, policy=default)

print(f"Subject: {msg['subject']}")
print(f"From: {msg['from']}")
print(f"Content-Type: {msg['Content-Type']}")

Selgitus:

• BytesParser võtab vastu toored baidandmed (nii edastatakse e-kirju) ja tagastab EmailMessage objekti.
• policy=default määrab parsimisreeglid.

Päiste avamine

Päised on hõlpsasti ligipääsetavad sõnastiku-laadsete võtmete kaudu. Pakett käsitleb automaatselt kodeeritud päiste (nt rahvusvaheliste märkedega teemade) dekodeerimist.

# ... (kasutades eelmisest parsimise näitest saadud 'msg' objekti)

print(f"Kuupäev: {msg['date']}")
print(f"Sõnumi ID: {msg['Message-ID'] if 'Message-ID' in msg else 'N/A'}")

# Mitu päist käsitlemine (nt 'Received' päised)
# from email.message import EmailMessage # Kui pole veel imporditud
# from email import message_from_string # Kiire stringi näite jaoks

multi_header_email = message_from_string(
    """
From: a@example.com
To: b@example.com
Subject: Mitme päise test
Received: from client.example.com (client.example.com [192.168.1.100])
        by server.example.com (Postfix) with ESMTP id 123456789
        for <b@example.com>; Mon, 1 Jan 2024 10:00:00 +0000 (GMT)
Received: from mx.another.com (mx.another.com [192.168.1.101])
        by server.example.com (Postfix) with ESMTP id 987654321
        for <b@example.com>; Mon, 1 Jan 2024 09:59:00 +0000 (GMT)

Sisu on siin.
"""
)

received_headers = multi_header_email.get_all('received')
if received_headers:
    print("\nSaadud päised:")
    for header in received_headers:
        print(f"- {header}")

Selgitus:

• Päisele ligipääs tagastab selle väärtuse stringina.
• get_all('header-name') on kasulik päiste jaoks, mis võivad esineda mitu korda (nagu Received).
• Pakett käsitleb päiste dekodeerimist, nii et väärtused nagu Subject: =?utf-8?Q?Global_Characters:_=E3=81=93=E3=82=93=E3=81=AB=E3=81=A1=E3=81=AF?= teisendatakse automaatselt loetavateks stringideks.

Sisu ekstraheerimine

Tegeliku sõnumi sisu ekstraheerimine nõuab kontrollimist, kas sõnum on mitmeosaline. Mitmeosaliste sõnumite puhul itereeritakse selle osi.

from email.message import EmailMessage
from email import message_from_string

multipart_email_raw = """
From: multi@example.com
To: user@example.com
Subject: Mitmeosaline e-posti test
Content-Type: multipart/alternative; boundary="_----------=_12345"

--_----------=_12345
Content-Type: text/plain; charset="utf-8"

Tervitused lihtteksti osast!

--_----------=_12345
Content-Type: text/html; charset="utf-8"

<html>
<body>
<h1>Tervitused HTML-osast!</h1>
<p>See on <strong>rikas tekstiga</strong> e-kiri.</p>
</body>
</html>

--_----------=_12345--
"""

msg = message_from_string(multipart_email_raw)

if msg.is_multipart():
    print("\n--- Mitmeosaline e-kirja sisu ---")
    for part in msg.iter_parts():
        content_type = part.get_content_type()
        charset = part.get_content_charset() or 'utf-8' # Vaikeväärtus utf-8, kui pole määratud
        payload = part.get_payload(decode=True) # Dekodeerige sisu baidid

        try:
            decoded_content = payload.decode(charset)
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent:\n{decoded_content}\n")
        except UnicodeDecodeError:
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent: (Binaarsed või dekodeerimatud andmed)\n")
            # Käsitlege binaarseid andmeid või proovige varukodeeringut
else:
    print("\n--- Üheosaline e-kirja sisu ---")
    charset = msg.get_content_charset() or 'utf-8'
    payload = msg.get_payload(decode=True)
    try:
        decoded_content = payload.decode(charset)
        print(f"Content-Type: {msg.get_content_type()}, Charset: {charset}\nContent:\n{decoded_content}\n")
    except UnicodeDecodeError:
        print(f"Content: (Binaarsed või dekodeerimatud andmed)\n")

Selgitus:

• is_multipart() määrab, kas e-kirjal on mitu osa.
• iter_parts() itereerib läbi mitmeosalise sõnumi kõigi alam-osade.
• get_content_type() tagastab täieliku MIME-tüübi (nt text/plain).
• get_content_charset() eraldab märgitüübi Content-Type päisest.
• get_payload(decode=True) on ülioluline: see tagastab *dekodeeritud* sisu baitidena. Seejärel peate need baidid .decode() abil õige märgitüübi järgi dekodeerima, et saada Pythoni string.

Manuste käsitlemine parsimise käigus

Manused on samuti osa mitmeosalisest sõnumist. Saate need tuvastada nende Content-Disposition päise abil ja salvestada nende dekodeeritud sisu.

from email.message import EmailMessage
from email import message_from_string
import os

# Example email with a simple attachment
email_with_attachment = """
From: attach@example.com
To: user@example.com
Subject: Dokument lisatud
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="_----------=_XYZ"

--_----------=_XYZ
Content-Type: text/plain; charset="utf-8"

Siin on teie soovitud dokument.

--_----------=_XYZ
Content-Type: application/pdf
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="document.pdf"

JVBERi0xLjQKMSAwIG9iagpbL1BERi9UZXh0L0ltYWdlQy9JbWFnZUkvSW1hZ0VCXQplbmRvYmoK

--_----------=_XYZ--
"""

msg = message_from_string(email_with_attachment)

output_dir = 'parsed_attachments'
os.makedirs(output_dir, exist_ok=True)

print("\n--- Manuste töötlemine ---")
for part in msg.iter_attachments():
    filename = part.get_filename()
    if filename:
        filepath = os.path.join(output_dir, filename)
        try:
            with open(filepath, 'wb') as f:
                f.write(part.get_payload(decode=True))
            print(f"Salvestati manus: {filepath} (Tüüp: {part.get_content_type()})")
        except Exception as e:
            print(f"Viga {filename} salvestamisel: {e}")
    else:
        print(f"Leiti manus ilma failinimeta (Content-Type: {part.get_content_type()})")

# Clean up the output directory
# import shutil
# shutil.rmtree(output_dir)

Selgitus:

• iter_attachments() annab konkreetselt osad, mis on tõenäoliselt manused (st neil on Content-Disposition: attachment päis või neid pole muul viisil klassifitseeritud).
• get_filename() eraldab failinime Content-Disposition päisest.
• part.get_payload(decode=True) toob manuse toore binaarse sisu, mis on juba dekodeeritud base64-st või quoted-printable-st.

Kodeeringute ja märgistikute dekodeerimine

Pakett email teeb suurepärast tööd, dekodeerides automaatselt tavalisi edastuskodeeringuid (nagu base64, quoted-printable), kui kutsute välja get_payload(decode=True). Tekstisisu puhul proovib see kasutada Content-Type päises määratud charset. Kui märgitüüpi pole määratud või see on kehtetu, peate seda võib-olla graatsiliselt käsitlema.

from email.message import EmailMessage
from email import message_from_string

# Example with a potentially problematic charset
email_latin1 = """
From: legacy@example.com
To: new_system@example.com
Subject: Erinõuded: àéíóú
Content-Type: text/plain; charset="iso-8859-1"

See sõnum sisaldab Latin-1 märke: àéíóú
"""

msg = message_from_string(email_latin1)

if msg.is_multipart():
    for part in msg.iter_parts():
        payload = part.get_payload(decode=True)
        charset = part.get_content_charset() or 'utf-8'
        try:
            print(f"Dekodeeritud (märgistik: {charset}): {payload.decode(charset)}")
        except UnicodeDecodeError:
            print(f"Dekodeerimine nurjus märgistikuga {charset}. Proovitakse varuvarianti...")
            # Varuvariandina tavaline märgistik või 'latin-1', kui seda oodatakse
            print(f"Dekodeeritud (varuvariandi Latin-1): {payload.decode('latin-1', errors='replace')}")
else:
    payload = msg.get_payload(decode=True)
    charset = msg.get_content_charset() or 'utf-8'
    try:
        print(f"Dekodeeritud (märgistik: {charset}): {payload.decode(charset)}")
    except UnicodeDecodeError:
        print(f"Dekodeerimine nurjus märgistikuga {charset}. Proovitakse varuvarianti...")
        print(f"Dekodeeritud (varuvariandi Latin-1): {payload.decode('latin-1', errors='replace')}")

Selgitus:

• Proovige alati kasutada Content-Type päises määratud märgistikku.
• Kasutage try-except UnicodeDecodeError plokki vastupidavuse tagamiseks, eriti kui tegemist on erinevate ja potentsiaalselt mittestandardsete allikate e-kirjadega.
• errors='replace' või errors='ignore' saab kasutada koos .decode()-ga, et käsitleda märke, mida ei saa sihtkodeeringuga kaardistada, vältides seega kokkujooksmist.

Täpsemad parsimisstsenaariumid

Pärismaailma e-kirjad võivad olla väga keerulised, sisaldades pesastatud mitmeosalisi struktuure. Paketi email rekursiivne olemus teeb nende navigeerimise lihtsaks. Saate kombineerida is_multipart() ja iter_parts(), et läbida sügavalt pesastatud sõnumeid.

from email.message import EmailMessage
from email import message_from_string

def parse_email_part(part, indent=0):
    prefix = "  " * indent
    content_type = part.get_content_type()
    charset = part.get_content_charset() or 'N/A'
    print(f"{prefix}Osa tüüp: {content_type}, Märgistik: {charset}")

    if part.is_multipart():
        for subpart in part.iter_parts():
            parse_email_part(subpart, indent + 1)
    elif part.get_filename(): # See on manus
        print(f"{prefix}  Manus: {part.get_filename()} (Suurus: {len(part.get_payload(decode=True))} baiti)")
    else: # See on tavaline tekst/html sisu osa
        payload = part.get_payload(decode=True)
        try:
            decoded_content = payload.decode(charset)
            # print(f"{prefix}  Sisu (esimesed 100 märki): {decoded_content[:100]}...") # Lühiduse huvides
        except UnicodeDecodeError:
            print(f"{prefix}  Sisu: (Binaarne või dekodeerimatu tekst)")

complex_email_raw = """
From: complex@example.com
To: receiver@example.com
Subject: Keeruline e-kiri HTML-i, lihtteksti ja manusega
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="outer_boundary"

--outer_boundary
Content-Type: multipart/alternative; boundary="inner_boundary"

--inner_boundary
Content-Type: text/plain; charset="utf-8"

Lihtteksti sisu.

--inner_boundary
Content-Type: text/html; charset="utf-8"

<html><body><h2>HTML sisu</h2></body></html>

--inner_boundary--

--outer_boundary
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="data.bin"

SGVsbG8gV29ybGQh

--outer_boundary--
"""

msg = message_from_string(complex_email_raw)
print("\n--- Keerulise e-kirja struktuuri läbimine ---")
parse_email_part(msg)

Selgitus:

• Rekursiivne funktsioon parse_email_part demonstreerib, kuidas läbida kogu sõnumipuu, tuvastades mitmeosalised osad, manused ja kehasisu igal tasandil.
• See muster on väga paindlik konkreetsete sisutüüpide ekstraheerimiseks sügavalt pesastatud e-kirjadest.

Loomine vs. Parsimine: võrdlev vaatenurk

Kuigi need on eraldiseisvad toimingud, on loomine ja parsimine sama mündi kaks külge: MIME-sõnumite käsitlemine. Ühe mõistmine aitab paratamatult teise mõistmisel kaasa.

Loomine (saatmine):

• Fookus: Päiste, sisu ja manuste õige kokkupanemine standarditele vastavaks MIME-struktuuriks.
• Peamine tööriist: email.message.EmailMessage koos meetoditega nagu set_content(), add_attachment(), add_alternative(), add_related().
• Peamised väljakutsed: Õigete MIME-tüüpide, märgistikute (eriti UTF-8 globaalse toe jaoks), `Content-Transfer-Encoding` ja õige päisevormingu tagamine. Vead võivad viia e-kirjade valesti kuvamiseni, manuste riknemiseni või sõnumite rämpspostiks märkimiseni.

Parsimine (vastuvõtmine):

• Fookus: Toore e-kirja baidivoo lahtivõtmine selle koostisosadeks, spetsiifiliste päiste, sisu ja manuste ekstraheerimine.
• Peamine tööriist: email.parser.BytesParser või email.message_from_bytes(), seejärel navigeerimine saadud EmailMessage objektiga, kasutades meetodeid nagu is_multipart(), iter_parts(), get_payload(), get_filename() ja päistele ligipääs.
• Peamised väljakutsed: Valesti vormistatud e-kirjade käsitlemine, märgifkodeeringute õige tuvastamine (eriti kui need on ebaselged), puuduvate päistega tegelemine ja andmete robustne ekstraheerimine erinevatest MIME-struktuuridest.

Sõnum, mille te konstrueerite kasutades `EmailMessage`, peaks olema `BytesParser` poolt täiuslikult parsitav. Samamoodi annab parsimise käigus toodetud MIME-struktuuri mõistmine teile ülevaate, kuidas ise keerulisi sõnumeid ehitada.

Parimad praktikad globaalse e-posti käsitlemiseks Pythoniga

Rakenduste puhul, mis suhtlevad globaalse publikuga või käsitlevad erinevaid e-posti allikaid, kaaluge järgmisi parimaid tavasid:

• Standardiseeri UTF-8-le: Kasutage alati UTF-8-t kogu tekstisisu jaoks, nii loomisel kui ka parsimise käigus oodates. See on globaalne standard märgifkodeeringu jaoks ja väldib mojibake'i (moonutatud tekst).
• Valideeri e-posti aadresse: Enne saatmist valideerige vastuvõtja e-posti aadressid, et tagada kohaletoimetatavus. Parsimise käigus olge valmis potentsiaalselt kehtetute või valesti vormistatud aadresside jaoks päistes `From`, `To` või `Cc`.
• Testige rangelt: Testige oma e-kirjade loomist erinevate e-posti klientidega (Gmail, Outlook, Apple Mail, Thunderbird) ja platvormidega, et tagada HTML-i ja manuste järjepidev renderdamine. Parsimiseks testige laia valiku näidiskirjadega, sealhulgas nendega, millel on ebatavalised kodeeringud, puuduvad päised või keerulised pesastatud struktuurid.
• Puhasta parsimisel sisend: Kohelge sissetulevatest e-kirjadest ekstraheeritud sisu alati ebausaldusväärsena. Puhastage HTML-sisu, et vältida XSS-rünnakuid, kui kuvate seda veebirakenduses. Valideerige manuste failinimed ja tüübid, et vältida kataloogi läbimist või muid turvaauke failide salvestamisel.
• Tugev veakäsitlus: Rakendage põhjalikke try-except plokke sisu dekodeerimisel või potentsiaalselt puuduvatele päistele ligipääsemisel. Käsitlege graatsiliselt UnicodeDecodeError või KeyError.
• Käsitle suuri manuseid: Olge teadlik manuste suurusest, nii loomisel (et vältida meiliserveri piirangute ületamist) kui ka parsimisel (et vältida liigset mälu- või kettaruumi tarbimist). Kaaluge suurte manuste voogesitust, kui teie süsteem seda toetab.
• Kasuta email.policy: Kriitiliste rakenduste puhul valige selgelt `email.policy` (nt `policy.SMTP`), et tagada range vastavus e-posti standarditele, mis võib mõjutada kohaletoimetatavust ja koostalitlusvõimet.
• Metainfo säilitamine: Parsimisel otsustage, millist metainfot (päiseid, algseid piiride stringe) on oluline säilitada, eriti kui ehitate e-posti arhiveerimis- või edastussüsteemi.

Järeldus

Pythoni pakett email on uskumatult võimas ja paindlik teek kõigile, kes vajavad e-kirjadega programmeerimise teel suhtlemist. Valdades nii MIME-sõnumite loomist kui ka sissetulevate e-kirjade robustset parsimist, avate võimaluse luua keerulisi e-posti automatiseerimissüsteeme, ehitada e-posti kliente, analüüsida e-posti andmeid ja integreerida e-posti funktsionaalsusi praktiliselt igasse rakendusse.

Pakett käsitleb läbimõeldult MIME-i alusstruktuuri keerukust, võimaldades arendajatel keskenduda oma e-posti interaktsioonide sisule ja loogikale. Olenemata sellest, kas saadate isikupärastatud uudiskirju globaalsele publikule või ekstraheerite kriitilisi andmeid automatiseeritud süsteemi aruannetest, osutub paketi email sügav mõistmine hindamatuks usaldusväärsete, koostalitlusvõimeliste ja globaalselt teadlike e-posti lahenduste loomisel.